const dayjs = require('dayjs');
import cloudHelper from '../helpers/cloud/cloud_helper';
// 使用统一配置入口引用模型
const { TaskModel } = require('../../config/models_config');
import SmartCache from '../../helpers/smart_cache';

// 创建任务缓存实例
const taskCache = new SmartCache('task', 5 * 60 * 1000, 20 * 1024 * 1024); // 5分钟缓存，20MB限制

/**
 * 任务仓储层
 * 负责任务数据的持久化和检索
 */
class TaskRepository {
  /**
   * 获取项目下的任务列表
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectTasks(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `project:${projectId}:list:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await taskCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('task/list', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        if (result && result.list) {
          result.list = result.list.map(item => new TaskModel(item));
        }
        
        return result;
      }, {
        // 设置重试选项
        retryCount: 3,
        retryDelay: 1000,
        // 设置依赖关系
        dependsOn: [`project:${projectId}`]
      });
    } catch (err) {
      console.error('[TaskRepository] getProjectTasks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取任务详情
   * @param {String} id 任务ID
   */
  async getTaskById(id) {
    if (!id) throw new Error('任务ID不能为空');
    
    const cacheKey = `detail:${id}`;
    
    try {
      // 尝试从缓存获取
      return await taskCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('task/detail', {id});
        
        // 转换为领域模型
        return result ? new TaskModel(result) : null;
      }, {
        // 设置重试选项
        retryCount: 2,
        retryDelay: 1000
      });
    } catch (err) {
      console.error('[TaskRepository] getTaskById 错误:', err);
      throw err;
    }
  }
  
  /**
   * 创建任务
   * @param {TaskModel} task 任务模型
   */
  async createTask(task) {
    try {
      // 验证任务数据
      const validation = task.validate();
      if (!validation.valid) {
        throw new Error('任务数据验证失败: ' + JSON.stringify(validation.errors));
      }
      
      // 转换为存储格式
      const data = task.toStorage();
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/create', {
        task: data
      });
      
      // 清除列表缓存
      taskCache.removeByPattern(`^project:${task.projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] createTask 错误:', err);
      throw err;
    }
  }
  
  /**
   * 更新任务
   * @param {TaskModel} task 任务模型
   */
  async updateTask(task) {
    try {
      if (!task._id) throw new Error('更新任务时ID不能为空');
      
      // 验证任务数据
      const validation = task.validate();
      if (!validation.valid) {
        throw new Error('任务数据验证失败: ' + JSON.stringify(validation.errors));
      }
      
      // 转换为存储格式
      const data = task.toStorage();
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/edit', {
        id: task._id,
        data: data
      });
      
      // 清除相关缓存
      taskCache.remove(`detail:${task._id}`);
      taskCache.removeByPattern(`^project:${task.projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] updateTask 错误:', err);
      throw err;
    }
  }
  
  /**
   * 更新任务状态
   * @param {String} id 任务ID
   * @param {String} status 新状态
   * @param {String} projectId 项目ID
   * @param {String} userId 操作用户ID
   */
  async updateTaskStatus(id, status, projectId, userId = '') {
    try {
      if (!id) throw new Error('任务ID不能为空');
      if (!status) throw new Error('任务状态不能为空');
      if (!projectId) throw new Error('项目ID不能为空');
      
      // 获取现有任务数据
      const task = await this.getTaskById(id);
      if (!task) {
        throw new Error('任务不存在');
      }
      
      // 使用领域模型的方法更新状态
      const updateResult = task.updateStatus(status, userId);
      if (!updateResult.success) {
        throw new Error(updateResult.message || '更新状态失败');
      }
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/status', {
        id: id,
        status: status,
        statusHistory: task.statusHistory
      });
      
      // 清除相关缓存
      taskCache.remove(`detail:${id}`);
      taskCache.removeByPattern(`^project:${projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] updateTaskStatus 错误:', err);
      throw err;
    }
  }
  
  /**
   * 删除任务
   * @param {String} id 任务ID
   * @param {String} projectId 项目ID
   */
  async deleteTask(id, projectId) {
    try {
      if (!id) throw new Error('任务ID不能为空');
      if (!projectId) throw new Error('项目ID不能为空');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/delete', {
        id: id
      });
      
      // 清除相关缓存
      taskCache.remove(`detail:${id}`);
      taskCache.removeByPattern(`^project:${projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] deleteTask 错误:', err);
      throw err;
    }
  }
  
  /**
   * 批量更新任务状态
   * @param {Array<String>} ids 任务ID数组
   * @param {String} status 新状态
   * @param {String} projectId 项目ID
   */
  async batchUpdateTaskStatus(ids, status, projectId) {
    try {
      if (!ids || !ids.length) throw new Error('任务ID不能为空');
      if (!status) throw new Error('任务状态不能为空');
      if (!projectId) throw new Error('项目ID不能为空');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/batch_status', {
        ids: ids,
        status: status
      });
      
      // 清除相关缓存
      ids.forEach(id => {
        taskCache.remove(`detail:${id}`);
      });
      taskCache.removeByPattern(`^project:${projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] batchUpdateTaskStatus 错误:', err);
      throw err;
    }
  }
  
  /**
   * 批量删除任务
   * @param {Array<String>} ids 任务ID数组
   * @param {String} projectId 项目ID
   */
  async batchDeleteTasks(ids, projectId) {
    try {
      if (!ids || !ids.length) throw new Error('任务ID不能为空');
      if (!projectId) throw new Error('项目ID不能为空');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/batch_delete', {
        ids: ids
      });
      
      // 清除相关缓存
      ids.forEach(id => {
        taskCache.remove(`detail:${id}`);
      });
      taskCache.removeByPattern(`^project:${projectId}:list:`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] batchDeleteTasks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 添加任务评论
   * @param {String} taskId 任务ID
   * @param {String} content 评论内容
   * @param {String} userId 用户ID
   * @param {String} userName 用户名称
   */
  async addTaskComment(taskId, content, userId, userName) {
    try {
      if (!taskId) throw new Error('任务ID不能为空');
      if (!content) throw new Error('评论内容不能为空');
      
      // 获取任务详情
      const task = await this.getTaskById(taskId);
      if (!task) {
        throw new Error('任务不存在');
      }
      
      // 使用领域模型添加评论
      const commentResult = task.addComment(content, userId, userName);
      if (!commentResult.success) {
        throw new Error(commentResult.message || '添加评论失败');
      }
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/add_comment', {
        id: taskId,
        comment: {
          content,
          userId,
          userName,
          createTime: dayjs().valueOf()
        }
      });
      
      // 清除缓存
      taskCache.remove(`detail:${taskId}`);
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] addTaskComment 错误:', err);
      throw err;
    }
  }
  
  /**
   * 添加子任务
   * @param {String} taskId 任务ID
   * @param {Object} subtaskData 子任务数据
   */
  async addSubtask(taskId, subtaskData) {
    try {
      if (!taskId) throw new Error('任务ID不能为空');
      if (!subtaskData || !subtaskData.title) throw new Error('子任务标题不能为空');
      
      // 获取任务详情
      const task = await this.getTaskById(taskId);
      if (!task) {
        throw new Error('任务不存在');
      }
      
      // 使用领域模型添加子任务
      const subtaskResult = task.addSubtask(subtaskData);
      if (!subtaskResult.success) {
        throw new Error(subtaskResult.message || '添加子任务失败');
      }
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('task/add_subtask', {
        id: taskId,
        subtask: subtaskData
      });
      
      // 清除缓存
      taskCache.remove(`detail:${taskId}`);
      if (task.projectId) {
        taskCache.removeByPattern(`^project:${task.projectId}:list:`);
      }
      
      return result;
    } catch (err) {
      console.error('[TaskRepository] addSubtask 错误:', err);
      throw err;
    }
  }
  
  /**
   * 搜索任务
   * @param {Object} params 搜索参数
   */
  async searchTasks(params = {}) {
    const cacheKey = `search:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await taskCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('task/search', params);
        
        // 转换为领域模型
        if (result && result.list) {
          result.list = result.list.map(item => new TaskModel(item));
        }
        
        return result;
      }, {
        // 较短的TTL，因为搜索结果变化较快
        ttl: 2 * 60 * 1000 // 2分钟
      });
    } catch (err) {
      console.error('[TaskRepository] searchTasks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取用户的任务列表
   * @param {String} userId 用户ID
   * @param {Object} params 查询参数
   */
  async getUserTasks(userId, params = {}) {
    if (!userId) throw new Error('用户ID不能为空');
    
    const cacheKey = `user:${userId}:tasks:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await taskCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('task/user_tasks', {
          userId,
          ...params
        });
        
        // 转换为领域模型
        if (result && result.list) {
          result.list = result.list.map(item => new TaskModel(item));
        }
        
        return result;
      }, {
        // 设置重试选项
        retryCount: 2,
        retryDelay: 1000,
        // 设置依赖关系
        dependsOn: [`user:${userId}`]
      });
    } catch (err) {
      console.error('[TaskRepository] getUserTasks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取缓存统计信息
   */
  getCacheStats() {
    return taskCache.getStats();
  }
  
  /**
   * 清除任务缓存
   */
  clearCache() {
    taskCache.clear();
    console.log('[TaskRepository] 任务缓存已清除');
  }
}

export default new TaskRepository(); 